package com.example.service;

import com.example.entity.User;
import com.example.exception.BusinessException;
import com.example.exception.SystemException;
import com.example.exception.AuthenticationException;
import com.example.exception.ValidationException;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

/**
 * 异常处理使用示例服务
 * 展示如何在业务代码中使用新的异常处理机制
 */
@Service
@Slf4j
public class ExampleService {
    
    /**
     * 用户登录示例
     * 展示认证异常的使用
     */
    public User login(String username, String password, String captcha) {
        // 验证码检查
        if (!isValidCaptcha(captcha)) {
            throw AuthenticationException.captchaError();
        }
        
        // 查找用户
        User user = findUserByUsername(username);
        if (user == null) {
            throw BusinessException.userNotFound(username);
        }
        
        // 检查用户状态
        if (!user.isEnabled()) {
            throw BusinessException.userDisabled();
        }
        
        if (user.isLocked()) {
            throw BusinessException.userLocked();
        }
        
        // 验证密码
        if (!isValidPassword(user, password)) {
            throw BusinessException.userPasswordError();
        }
        
        log.info("用户登录成功: {}", username);
        return user;
    }
    
    /**
     * 创建用户示例
     * 展示业务异常的使用
     */
    public User createUser(User user) {
        // 检查用户名是否已存在
        if (existsByUsername(user.getUsername())) {
            throw BusinessException.userAlreadyExists(user.getUsername());
        }
        
        // 检查邮箱是否已存在
        if (existsByEmail(user.getEmail())) {
            throw BusinessException.dataAlreadyExists("邮箱");
        }
        
        try {
            // 保存用户
            User savedUser = saveUser(user);
            log.info("用户创建成功: {}", user.getUsername());
            return savedUser;
        } catch (Exception e) {
            log.error("用户创建失败: {}", user.getUsername(), e);
            throw BusinessException.dataSaveFailed();
        }
    }
    
    /**
     * 删除用户示例
     * 展示权限和业务异常的使用
     */
    public void deleteUser(Long userId, String currentUsername) {
        // 查找用户
        User user = findUserById(userId);
        if (user == null) {
            throw BusinessException.userNotFound();
        }
        
        // 检查是否为系统管理员（不能删除）
        if ("admin".equals(user.getUsername())) {
            throw BusinessException.permissionDenied("不能删除系统管理员");
        }
        
        // 检查是否删除自己
        if (user.getUsername().equals(currentUsername)) {
            throw BusinessException.permissionDenied("不能删除自己");
        }
        
        try {
            // 检查是否有关联数据
            if (hasRelatedData(userId)) {
                throw BusinessException.dataDeleteFailed();
            }
            
            // 删除用户
            deleteUserById(userId);
            log.info("用户删除成功: {}", user.getUsername());
        } catch (Exception e) {
            log.error("用户删除失败: {}", user.getUsername(), e);
            throw SystemException.databaseUpdateError(e);
        }
    }
    
    /**
     * 文件上传示例
     * 展示文件相关异常的使用
     */
    public String uploadFile(byte[] fileData, String fileName, String fileType) {
        // 检查文件大小
        if (fileData.length > 10 * 1024 * 1024) { // 10MB
            throw BusinessException.fileSizeExceeded();
        }
        
        // 检查文件类型
        if (!isAllowedFileType(fileType)) {
            throw BusinessException.fileTypeNotSupported();
        }
        
        try {
            // 保存文件
            String filePath = saveFile(fileData, fileName);
            log.info("文件上传成功: {}", fileName);
            return filePath;
        } catch (Exception e) {
            log.error("文件上传失败: {}", fileName, e);
            throw BusinessException.fileUploadFailed();
        }
    }
    
    /**
     * 外部服务调用示例
     * 展示系统异常的使用
     */
    public String callExternalService(String serviceUrl, Object requestData) {
        try {
            // 调用外部服务
            return invokeExternalService(serviceUrl, requestData);
        } catch (Exception e) {
            log.error("外部服务调用失败: {}", serviceUrl, e);

            // 根据异常类型进行不同处理
            if (e instanceof java.net.SocketTimeoutException) {
                throw SystemException.externalServiceTimeout("支付服务");
            } else if (e instanceof java.net.ConnectException) {
                throw SystemException.externalServiceUnavailable("支付服务");
            } else {
                throw SystemException.externalServiceError("支付服务", e);
            }
        }
    }
    
    /**
     * 数据验证示例
     * 展示参数验证异常的使用
     */
    public void validateUserData(User user) {
        if (user == null) {
            throw new ValidationException("PARAM_ERROR", "用户数据不能为空");
        }
        
        if (user.getUsername() == null || user.getUsername().trim().isEmpty()) {
            throw ValidationException.parameterMissing("username");
        }
        
        if (user.getUsername().length() < 3) {
            throw ValidationException.parameterInvalid("username", "长度不能少于3个字符");
        }
        
        if (user.getEmail() == null || !isValidEmail(user.getEmail())) {
            throw ValidationException.parameterInvalid("email", "邮箱格式不正确");
        }
    }
    
    // ========== 模拟的私有方法 ==========
    
    private boolean isValidCaptcha(String captcha) {
        // 模拟验证码验证逻辑
        return "1234".equals(captcha);
    }
    
    private User findUserByUsername(String username) {
        // 模拟查找用户逻辑
        if ("admin".equals(username)) {
            User user = new User();
            user.setUsername(username);
            user.setEnabled(true);
            user.setLocked(false);
            return user;
        }
        return null;
    }
    
    private User findUserById(Long userId) {
        // 模拟根据ID查找用户
        return new User();
    }
    
    private boolean isValidPassword(User user, String password) {
        // 模拟密码验证逻辑
        return "123456".equals(password);
    }
    
    private boolean existsByUsername(String username) {
        // 模拟检查用户名是否存在
        return "admin".equals(username);
    }
    
    private boolean existsByEmail(String email) {
        // 模拟检查邮箱是否存在
        return "admin@example.com".equals(email);
    }
    
    private User saveUser(User user) {
        // 模拟保存用户
        return user;
    }
    
    private void deleteUserById(Long userId) {
        // 模拟删除用户
    }
    
    private boolean hasRelatedData(Long userId) {
        // 模拟检查是否有关联数据
        return false;
    }
    
    private boolean isAllowedFileType(String fileType) {
        // 模拟文件类型检查
        return "image/jpeg".equals(fileType) || "image/png".equals(fileType);
    }
    
    private String saveFile(byte[] fileData, String fileName) {
        // 模拟文件保存
        return "/uploads/" + fileName;
    }
    
    private String invokeExternalService(String serviceUrl, Object requestData) {
        // 模拟外部服务调用
        return "success";
    }
    
    private boolean isValidEmail(String email) {
        // 模拟邮箱格式验证
        return email != null && email.contains("@");
    }
}
